# ConfigManager.ts模板
MANAGER_SCRIPT_CONFIG = """
import GameConfig from "../../GameConfig";
[Script_Import]

/**
 * -----------------------------------------------
 * Config数据管理
 * -----------------------------------------------
 * 
 * 自动生成代码不要修改
 * 
 * 需先加载json文件完成后再获取数据：
 * ConfigManager.GetInstance().loadConfigFile(Laya.Handler.create(this, () => {
 *     // 读取数据
 * }));
 */
export default class ConfigManager{

    private static instance: any = null;

    private InitComplete : Laya.Handler = null;

    /**
     * 获取单例对象
     */
    public static GetInstance()
    {
        if (this.instance == null)
        {
            this.instance = new ConfigManager();
        }
        return this.instance;
    }

    constructor() {
        
    }

    /**
     * 加载Config序列化生成的json文件
     */
    public loadConfigFile(initComplete? : Laya.Handler) {
        if (!GameConfig.ConfigFilePath) {
            return;
        }
        this.InitComplete = initComplete;

        Laya.loader.load(GameConfig.ConfigFilePath, Laya.Handler.create(this, () => {
            const configDatas = Laya.loader.getRes(GameConfig.ConfigFilePath);
            this.Deserialize(configDatas);
        }));
    }

    /**
     * 反序列化所有Config数据
     * @param data Config序列化生成的json文件内容
     */
    private Deserialize(data: any) {
        const _keys = Object.keys(data);
[Sheet_Deserialize]

        this.InitComplete.run();
    }
}
"""


# Excel序列化自动生成的模板
TS_CODE_CONFIG = """
import Dictionary from "../Dictionary";

/**
 * -----------------------------------------------
 * ItemSheet数据        
 * -----------------------------------------------
 * 自动生成代码不要修改
 */
export default class [ExcelName] {

[TS_FIELD_List]

    constructor(data: any) {
[TS_FIELD_INIT_CONFIG]
    }

    /** 数据字典 */
    private static dictionary: Dictionary<number, [ExcelName]> = new Dictionary<number, [ExcelName]>();

    /**
     * 根据Key获取Value
     */
    public static getValue(_key: number): [ExcelName] {
        return [ExcelName].dictionary.get(_key);
    }

    /**
     * 判断是否包含Key
     */
    public static containkey(_key: number): boolean {
        return [ExcelName].dictionary.containkey(_key);
    }

    /**
     * 获取[ExcelName]所有Key
     */
    public static getKeys(): number[] {
        return [ExcelName].dictionary.getKeys();
    }

    /**
     * 获取[ExcelName]所有数据
     */
    public static getValues(): [ExcelName][] {
        return [ExcelName].dictionary.getValues();
    }

    /**
     * 获取数据长度
     */
    public static Count(): number {
        return [ExcelName].dictionary.Count;
    }

    /**
     * 反序列化，只能由ConfigManager自动调用，勿在其他地方调用
     * @param data 
     */
    public static Deserialize(data: any) {
        if (data == null) {
            return;
        }
        
        data.forEach(element => {
            let value: [ExcelName] = new [ExcelName](element);
            this.dictionary.add([MainKeyFlag], value);
        });
    }
}
"""


# 自定义字典类模板
DICTIONARY_SCRIPT_CONFIG = """
import { KeyValue } from "../../core/HashMap/HashMap";

export interface DictionaryKV<K, V> {
    key: K;
    value: V;
}


/**
 * -----------------------------------------------
 * 自定义字典结构，用于保存Config的数据
 * -----------------------------------------------
 * 自动生成代码不要修改
 */
export default class Dictionary<K, V>{

    private _list: DictionaryKV<K, V>[] = [];
    private _keyList = [];

    /**
     * 获取字典
     */
    public get Dictionary():DictionaryKV<K, V>[]{
        return this._list;
    }

    /**
     * 字典长度
     */
    public get Count():number{
        return this._keyList.length;
    }

    /**
     * 存储数据
     * @param key 数据key
     * @param value 数据
     */
    public add(_key: K, _value: V) {
        const data:DictionaryKV<K,V> = {key:_key,value:_value};
        const index:number = this.getIndexByKey(_key);
        if(index !== -1){
            // 已存在，刷新数值
            this._list[index] = data;
        }else{
            this._list.push(data);
            this.addKey(_key);
        }
    }


    /**
     * 获取数据
     * @param key 数据key
     */
    public get(_key: K):V {
        const index : number = this.getIndexByKey(_key);
        if(index != -1){
            const data : DictionaryKV<K,V> = this._list[index];
            return data.value;
        }
        return null;
    }

    /**
     * 删除数据
     * @param key 数据key 
     */
    public remove(_key: K):V {
        const index : number = this.getIndexByKey(_key);
        if(index !== -1){
            const data:DictionaryKV<K,V> = this._list[index];
            this._list.splice(index ,1);
            this.removeKey(_key);
            return data.value;
        }
        return null;
    }


    /**
     * 清空字典
     */
    public clear(){
        this._list.splice(0,this._list.length);
        this._keyList.splice(0,this._keyList.length);
    }

    /**
     * 判断Key是否存在
     * @param key 数据key
     */
    public containkey(_key: K) {
        const index : number = this.getIndexByKey(_key);
        return index !== -1;
    }

    /**
     * 获取全部数据
     */
    public getValues() {
        let datas:V[] = [];
        if(this._list){
            this._list.forEach(element => {
                datas.push(element.value); 
            });
        }

        return datas;
    }

    /**
     * 获取全部key
     */
    public getKeys() {
        let keys:K[] = [];
        if(this._list){
            this._list.forEach(element => {
                keys.push(element.key); 
            });
        }
        return keys;
    }

    /**
     * 添加键到键列表
     */
    private addKey(_key: K) {
        if(this._keyList.indexOf(_key) < 0){
            this._keyList.push(_key);
        }
    }

    /** 从键列表中删除键值 */
    private removeKey(_key: K) {
        const index : number = this.getIndexByKey(_key);
        if(index >= 0){
            this._keyList.splice(index , 1);
        }
    }

    /**
     * 通过Key获取索引
     * @param key key值
     */
    private getIndexByKey(key:K):number{
        const index:number = this._keyList.indexOf(key);
        return index;
    }

   
}
"""
